package controller

import (
	"context"
	"errors"
	"sale-admin/config"
	"sale-admin/config/mysql"
	"sale-admin/config/redis"
	"sale-admin/internal/app/web/schema"
	"sale-admin/internal/app/web/service/lottery"
	"sale-admin/internal/app/web/service/order"
	"sale-admin/internal/models"

	"192.168.1.75/go-pkg/errorx"
	"192.168.1.75/go-pkg/helper"
	"192.168.1.75/go-pkg/redisx"
	"192.168.1.75/go-pkg/response"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
)

// LotteryActivity 抽奖活动
type LotteryActivity struct{}

// Add 新增活动
func (LotteryActivity) Add(c *gin.Context) {
	var params struct {
		ID                  string                        `json:"id"`
		Name                string                        `json:"name"`
		OrderAmountRequired int                           `json:"order_amount_required"`
		OrderAmount         float64                       `json:"order_amount"`
		StartTime           int                           `json:"start_time"`
		EndTime             int                           `json:"end_time"`
		Status              int                           `json:"status"`
		Type                int                           `json:"type"`
		Desc                string                        `json:"desc"`
		TotalWinTimes       int                           `json:"total_win_times"`
		DailyWinTimes       int                           `json:"daily_win_times"`
		TotalLotteryTimes   int                           `json:"total_lottery_times"`
		DaliyLotteryTimes   int                           `json:"daliy_lottery_times"`
		WechatImg           string                        `json:"wechat_img"`
		ServicePhone        string                        `json:"service_phone"`
		AllowCitys          string                        `json:"allow_citys"`
		AllowRobots         string                        `json:"allow_robots"`
		AllowGoods          string                        `json:"allow_goods"`
		ThemesColor         string                        `json:"themes_color"`
		ThemesImage         string                        `json:"themes_image"`
		RedemptionStartTime int                           `json:"redemption_start_time"`
		RedemptionEndTime   int                           `json:"redemption_end_time"`
		RedemptionStartWeek string                        `json:"redemption_start_week"`
		PrizeData           []schema.LotteryPrizeRuleData `json:"prize_data"`
	}

	c.ShouldBindBodyWith(&params, binding.JSON)

	// 添加、编辑【锦鲤活动】
	err := lottery.LotteryService{}.Add(
		c.GetString("merchant_id"),
		params.ID,                  // 活动id. 有值时代表编辑
		params.Name,                // 活动名称
		params.OrderAmountRequired, // 订单是否需要消费
		params.OrderAmount,         // 订单需要消费的金额
		params.StartTime,           // 开始时间
		params.EndTime,             // 结束时间
		params.Status,              // 活动状态
		params.Type,                // 活动类型
		params.Desc,                // 活动描述
		params.TotalWinTimes,       // 最大可以中奖的次数
		params.DailyWinTimes,       // 单日可以中奖的次数
		params.TotalLotteryTimes,   // 总共可以抽奖的次数
		params.DaliyLotteryTimes,   // 单日可以抽奖的次数
		params.WechatImg,           // 微信二维码
		params.ServicePhone,        // 服务电话
		params.AllowCitys,          // 允许城市
		params.AllowRobots,         // string 允许的机器
		params.AllowGoods,          // string 允许的商品ID
		params.ThemesColor,         // string 主题背景
		params.ThemesImage,         // string 自定义图片
		params.RedemptionStartTime, // 固定日期开始时间
		params.RedemptionEndTime,   // 固定日期结束时间
		params.RedemptionStartWeek, // 固定时长
		params.PrizeData,           // 奖项设置
	)
	response.JSON(c, nil, err)
}

// Del 活动 - 没有开始的可以删
func (LotteryActivity) Del(c *gin.Context) {
	var params struct {
		ID string `json:"id"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	err := lottery.LotteryService{}.Del(MerchantID, params.ID)
	response.JSON(c, nil, err)
}

// SetStatus 修改活动状态：1启动 2禁用
func (LotteryActivity) SetStatus(c *gin.Context) {
	var params struct {
		ID     string `json:"id"`
		Status int    `json:"status"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	err := lottery.LotteryService{}.SetStatus(MerchantID,
		params.ID,
		params.Status,
	)
	response.JSON(c, nil, err)
}

// 活动列表
func (LotteryActivity) All(c *gin.Context) {
	var params struct {
		Page                int     `json:"page"`
		Limit               int     `json:"limit"`
		Name                string  `json:"name"`
		OrderAmountRequired int     `json:"order_amount_required"`
		OrderAmount         float64 `json:"order_amount"`
		StartTime           string  `json:"start_time"`
		EndTime             string  `json:"end_time"`
		Status              int     `json:"status"`
		Type                int     `json:"type"`
		Desc                string  `json:"desc"`
		WinOdds             float64 `json:"win_odds"`
		TotalWinTimes       int     `json:"total_win_times"`
		DailyWinTimes       int     `json:"daily_win_times"`
		TotalLotteryTimes   int     `json:"total_lottery_times"`
		DaliyLotteryTimes   int     `json:"daliy_lottery_times"`
		WechatImg           string  `json:"wechat_img"`
		ServicePhone        string  `json:"service_phone"`
		AllowCitys          string  `json:"allow_citys"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	data, count, err := lottery.LotteryService{}.All(
		c.Request.Context(),
		MerchantID,
		params.Page,
		params.Limit,
		params.Name,
		params.OrderAmountRequired,
		params.OrderAmount,
		params.StartTime,
		params.EndTime,
		params.Status,
		params.Type,
		params.Desc,
		params.WinOdds,
		params.TotalWinTimes,
		params.DailyWinTimes,
		params.TotalLotteryTimes,
		params.DaliyLotteryTimes,
		params.WechatImg,
		params.ServicePhone,
		params.AllowCitys,
	)
	response.JSON(c, gin.H{
		"data":  data,
		"count": count,
	}, err)
}

// SendCms 锦鲤活动，发送短信验证码
func (LotteryActivity) SendCode(c *gin.Context) {

	var params struct {
		Phone string `json:"phone"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)

	// 选择发送模版，开始发送短信
	templateCode := config.Config.SMSTemplateCode
	rds := redis.NewDB()
	err := helper.SendSMSCode(rds, params.Phone, templateCode, 5, 60)
	if err != nil {
		response.JSON(c, nil, errorx.New("获取验证码失败, 请检查网络", -1))
		return
	}
	response.JSON(c, nil, errorx.New("短信发送成功", 0))
}

// 锦鲤活动列表
func (LotteryActivity) List(c *gin.Context) {
	var params struct {
		Page                int     `json:"page"`
		Limit               int     `json:"limit"`
		Name                string  `json:"name"`
		OrderAmountRequired int     `json:"order_amount_required"`
		OrderAmount         float64 `json:"order_amount"`
		StartTime           string  `json:"start_time"`
		EndTime             string  `json:"end_time"`
		Status              int     `json:"status"`
		ActivityStatus      int     `json:"lottery_status"`
		Type                int     `json:"type"`
		Desc                string  `json:"desc"`
		WinOdds             float64 `json:"win_odds"`
		TotalWinTimes       int     `json:"total_win_times"`
		DailyWinTimes       int     `json:"daily_win_times"`
		TotalLotteryTimes   int     `json:"total_lottery_times"`
		DaliyLotteryTimes   int     `json:"daliy_lottery_times"`
		WechatImg           string  `json:"wechat_img"`
		ServicePhone        string  `json:"service_phone"`
		AllowCitys          string  `json:"allow_citys"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	data, count, err := lottery.LotteryService{}.List(
		c.Request.Context(),
		MerchantID,
		params.Page,
		params.Limit,
		params.Name,
		params.OrderAmountRequired,
		params.OrderAmount,
		params.StartTime,
		params.EndTime,
		params.Status,
		params.ActivityStatus, //1未开始 2进行中 3已结束
		params.Type,
		params.Desc,
		params.WinOdds,
		params.TotalWinTimes,
		params.DailyWinTimes,
		params.TotalLotteryTimes,
		params.DaliyLotteryTimes,
		params.WechatImg,
		params.ServicePhone,
		params.AllowCitys,
	)
	response.JSON(c, gin.H{
		"data":  data,
		"count": count,
	}, err)
}

// OrderList 抽奖活动明细列表
func (LotteryActivity) OrderList(c *gin.Context) {
	var params struct {
		Page  int `json:"page"`
		Limit int `json:"limit"`

		ActivityId string `json:"activity_id"` //活动ID

		ProvinceID string `json:"province_id"` //省ID
		CityID     string `json:"city_id"`     //市ID
		DistrictID string `json:"district_id"` //地区
		LocationID string `json:"location_id"` //商场ID

		ShopID  *[]string `json:"shop_id"`  //商户查询
		SalesID string    `json:"sales_id"` //设备ID
		RobotID string    `json:"robot_id"` //机器ID

		StartTime int `json:"start_time"` //开始时间
		EndTime   int `json:"end_time"`   //结束时间

		PaymentID   string `json:"payment_id"`   //支付方式ID
		OrderStatus string `json:"order_status"` //订单状态
		GoodsName   string `json:"goods_name"`   //商品名称
		OutTradeNo  string `json:"out_trade_no"` //订单号

		PrizeResult string `json:"prize_result"` //参与抽奖类型

		PayStatus int `json:"pay_status"`
	}
	err := c.ShouldBindBodyWith(&params, binding.JSON)
	if err != nil {
		response.JSON(c, nil, errorx.New("参数错误", -1))
		return
	}
	// 获取商户ID
	merchantID := c.GetString("merchant_id")
	// 获取商户列表
	var shopIDList = []string{}
	if params.ShopID != nil {
		shopIDList = append(shopIDList, *params.ShopID...)
	}
	// 获取抽奖订单明细
	data, count, err := order.OrderService{}.LotteryOrderList(
		c.Request.Context(),

		params.Page,
		params.Limit,

		params.ActivityId,

		params.ProvinceID,
		params.CityID,
		params.DistrictID,
		params.LocationID,

		shopIDList,
		params.RobotID,
		params.StartTime,
		params.EndTime,

		params.OutTradeNo,
		params.GoodsName,
		params.OrderStatus,
		params.PaymentID,
		merchantID,
	)
	response.JSON(c, gin.H{
		"list":  data,
		"total": count,
	}, err)
}

// 访问量统计
func (LotteryActivity) Visit(c *gin.Context) {
	var params struct {
		ActivityID string `json:"activity_id"`
		SalesID    string `json:"sales_id"`
		OutTradeNo string `json:"out_trade_no"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	err := lottery.LotteryService{}.
		Visit(
			MerchantID,
			params.ActivityID,
			params.SalesID,
			params.OutTradeNo,
		)
	response.JSON(c, nil, err)
}

// Detail 抽奖活动详情
func (LotteryActivity) Detail(c *gin.Context) {
	var params struct {
		ID string `json:"id"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	info, err := lottery.LotteryService{}.Detail(MerchantID, params.ID)
	response.JSON(c, info, err)
}

// PrizeList 抽奖活动列表
func (LotteryActivity) PrizeList(c *gin.Context) {
	var params struct {
		ActivityID string `json:"activity_id"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	data, err := lottery.LotteryService{}.PrizeList(MerchantID, params.ActivityID)
	// response.JSON(c, info, err)
	response.JSON(c, gin.H{
		"data":  data,
		"count": len(data),
	}, err)
}

// 详情 [ 只获取部分字段 ]
func (LotteryActivity) DetailOnly(c *gin.Context) {
	var params struct {
		ID string `json:"id"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	info, err := lottery.LotteryService{}.DetailOnly(MerchantID, params.ID)
	response.JSON(c, info, err)
}

// LotteryMember 抽奖会员
type LotteryMember struct{}

// GetLotteryData 获取锦鲤活动数据
func (LotteryMember) GetLotteryData(
	rdb redisx.Client,
	keywords string,
) (
	bool,
	error,
) {
	if rdb == nil {
		return false, errors.New("invalid redis conn")
	}
	// redisCtx, redisCtxCancel := context.WithTimeout(
	// 	context.Background(), // 上下文
	// 	time.Second*3,        // 超时时间
	// )
	// defer redisCtxCancel()
	// var data = make(map[])
	// map := rdb.HGetAll(redisCtx, define.RedisLotteryActivityStatistic).Result() // TodayOrderPayment
	// if len(map) == 0 {
	// return false, errors.New("invalid keywords")
	// }
	return true, nil
}

// 【 4.15新版】参与抽奖，抽奖成功马上创单，告知安卓出货
func (LotteryMember) PartInLottery(c *gin.Context) {

	var params struct {
		ActivityID string `json:"activity_id"`  // 【必填】 活动ID，抽奖活动是哪个
		SalesID    string `json:"sales_id"`     // 【必填】 机器ID，抽奖在哪台机器
		OutTradeNo string `json:"out_trade_no"` // 【一个订单只能抽一次】
	}
	err := c.ShouldBindBodyWith(&params, binding.JSON)
	if err != nil {
		response.JSON(c, nil, errorx.New("参数错误！", -1))
		return
	}

	// 根据活动ID，查询活动类型。获取如果扭蛋机？如果是锦鲤活动？... 不同的活动类型，走不同的抽奖接口
	// ...

	if params.SalesID == "" {
		response.JSON(c, nil, errorx.New("机器识别码为空", -1))
		return
	}
	if params.OutTradeNo == "" {
		response.JSON(c, nil, errorx.New("订单号不能为空", -1))
		return
	}

	// 1.查询订单是否存在
	countOrder, _ := lottery.LotteryMemberActivityLogService{}.CheckOrder(
		context.Background(),
		params.OutTradeNo,
	)
	if countOrder == 0 {
		response.JSON(c, nil, errorx.New("当前订单不存在", -1))
		return
	}

	// 2.判断是否重复抽奖（抽奖订单表 ma_lottery_order）
	count, _ := lottery.LotteryOrderService{}.CheckOrderOfLottery(
		context.Background(),
		params.ActivityID,
		params.OutTradeNo,
	)
	if count > 0 {
		response.JSON(c, nil, errorx.New("当前订单已经参与，无法再次抽奖", -1))
		return
	}

	// 3. 新版的参与抽奖 ..
	res, err := lottery.LotteryMemberService{}.PartInLottery(
		params.ActivityID,
		params.SalesID,
		params.OutTradeNo,
	)
	if res == nil && err != nil {
		response.JSON(c, nil, err)
	} else {
		response.JSON(c, res, errorx.New("参与成功！", 0))
	}

}

// 用户当日购买完成后，参与抽奖，短信通知用户兑奖码是什么
func (LotteryMember) GetLotteryCode(c *gin.Context) {

	var params struct {
		Code       string `json:"code"`         // 【必填】 注册登录的验证码，这个之前由/public/lottery-member/add注册（登录）接口单独完成，现在合并了
		Phone      string `json:"phone"`        // 【必填】 用户手机号
		ActivityID string `json:"activity_id"`  // 【必填】 活动ID，抽奖活动是哪个
		SalesID    string `json:"sales_id"`     // 【必填】 机器ID，抽奖在哪台机器
		OutTradeNo string `json:"out_trade_no"` // 【哪个订单】一个订单只能抽奖一次，不能一个订单多次抽奖
	}
	err := c.ShouldBindBodyWith(&params, binding.JSON)
	if err != nil {
		response.JSON(c, nil, errorx.New("参数错误！", -1))
		return
	}

	if params.Phone == "" {
		response.JSON(c, nil, errorx.New("手机号为空", -1))
		return
	}
	if params.SalesID == "" {
		response.JSON(c, nil, errorx.New("机器识别码为空", -1))
		return
	}
	if params.OutTradeNo == "" {
		response.JSON(c, nil, errorx.New("订单号不能为空", -1))
		return
	}

	// 1.验证码验证会员信息（存在登录、不存在注册） （start）=============================
	if params.Code == "" {
		response.JSON(c, nil, errorx.New("验证码不能为空", -1))
		return
	}
	// redis验证码校验
	boolean, err := helper.CheckSMSCode(redis.NewDB(), params.Phone, params.Code)
	if !boolean || err != nil {
		response.JSON(c, nil, errorx.New("短信验证码错误", -1))
		return
	}

	// 校验手机号是否存在, 存在直接登录
	var info models.MaLotteryMember
	var count int64
	mysql.NewDB().Model(&models.MaLotteryMember{}).
		Where("phone = ?", params.Phone).
		Take(&info).
		Count(&count)
	// 检查注册用户是否存在
	if count > 0 {
		// 参与日志
		// response.JSON(c, nil, errorx.New("登录成功！", 0))  //以前是一个接口，需要返回。
	} else {
		// 开始注册
		// 添加、编辑【锦鲤会员】
		err = lottery.LotteryMemberService{}.Add(
			c.GetString("merchant_id"),
			"", // 会员ID（ 这里是注册，不涉及到修改，所以ID 不用传）
			params.Phone,
			params.SalesID,
			params.OutTradeNo,
			params.ActivityID,
		)
		if err != nil {
			// 返回错误信息，比如注册失败，这种需要提示
			response.JSON(c, nil, errorx.New("注册失败！", -1))
		}
	}
	// 记录访客记录
	_ = lottery.LotteryMemberActivityLogService{}.Add(
		3,                 // 访客
		params.SalesID,    // 机器识别码，用于查找当前注册的用户的来源
		params.ActivityID, // 活动ID，必填
		info.ID,           // 用户id，这个上面有查询
		params.OutTradeNo, // 订单号，用于溯源
		params.Phone,      // 手机号，保证身份唯一
		"",
	)
	// 验证会员,并保证会员可以参与抽奖 （end）=============================

	// 1.检查订单是否存在
	countOrder, _ := lottery.LotteryMemberActivityLogService{}.CheckOrder(
		context.Background(),
		params.OutTradeNo,
	)
	if countOrder == 0 {
		response.JSON(c, nil, errorx.New("当前订单不存在", -1))
		return
	}

	// 1.检查订单是否已经参与 -- 换成兑奖码表
	count, _ = lottery.LotteryMemberActivityLogService{}.CheckOrderOfLottery(
		context.Background(),
		params.ActivityID,
		params.OutTradeNo,
	)

	if count > 0 {
		response.JSON(c, nil, errorx.New("当前订单已经参与，无法再次抽奖", -1))
		return
	}
	// 2. 参与抽奖,成功则返回锦鲤号码，否则提示抽奖失败。 （注：raffle_code 锦鲤号码）
	raffle_code, err := lottery.LotteryMemberService{}.GetLotteryCode(
		params.ActivityID,
		params.SalesID,
		params.Phone,
		params.OutTradeNo,
	)
	if raffle_code == "" && err != nil {
		response.JSON(c, nil, err)
	} else {
		response.JSON(c, raffle_code, errorx.New("参与成功！", 0))
	}
}

// Add 注册会员
func (LotteryMember) Add(c *gin.Context) {
	var params struct {
		ID         string `json:"id"`
		SalesID    string `json:"sales_id"`
		ActivityID string `json:"activity_id"`
		OutTradeNo string `json:"out_trade_no"`
		Phone      string `json:"phone"`
		Code       string `json:"code"`
	}
	err := c.ShouldBindBodyWith(&params, binding.JSON)
	if err != nil {
		response.JSON(c, nil, errorx.New("参数错误！", -1))
		return
	}

	// 1. 验证会员 （start）=============================
	if params.Code == "" {
		response.JSON(c, nil, errorx.New("验证码不能为空", -1))
		return
	}
	// redis验证码校验
	boolean, err := helper.CheckSMSCode(redis.NewDB(), params.Phone, params.Code)
	if !boolean || err != nil {
		response.JSON(c, nil, errorx.New("短信验证码错误", -1))
		return
	}

	// 校验手机号是否存在, 存在直接登录
	var info models.MaLotteryMember
	var count int64
	mysql.NewDB().Model(&models.MaLotteryMember{}).
		Where("phone = ?", params.Phone).
		Take(&info).
		Count(&count)
	// 检查注册用户是否存在
	if count > 0 {
		// 参与日志
		response.JSON(c, nil, errorx.New("登录成功！", 0))
	}
	// 验证会员 （end）=============================

	// 添加、编辑【锦鲤会员】
	err = lottery.LotteryMemberService{}.Add(
		c.GetString("merchant_id"),
		params.ID,
		params.Phone,
		params.SalesID,
		params.OutTradeNo,
		params.ActivityID,
	)
	if err == nil {
		response.JSON(c, nil, errorx.New("注册成功！", 0))
	} else {
		response.JSON(c, nil, errorx.New("注册失败！", -1))
	}
}

// Del
func (LotteryMember) Del(c *gin.Context) {
	var params struct {
		ID string `json:"id"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	err := lottery.LotteryMemberService{}.Del(MerchantID, params.ID)
	response.JSON(c, nil, err)
}

// 会员列表
func (LotteryMember) List(c *gin.Context) {
	var params struct {
		Page           int    `json:"page"`
		Limit          int    `json:"limit"`
		Name           string `json:"name"`
		ProvinceID     string `json:"province_id"`
		CityID         string `json:"city_id"`
		Phone          string `json:"phone"`
		Status         int    `json:"status"`
		StartCreatedAt int    `json:"start_created_at"`
		EndCreatedAt   int    `json:"end_created_at"`
		StartUpdatedAt int    `json:"start_updated_at"`
		EndUpdatedAt   int    `json:"end_updated_at"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)

	MerchantID := c.GetString("merchant_id")

	// 返回会员列表数据
	data, count, err := lottery.LotteryMemberService{}.List(
		c.Request.Context(),
		MerchantID,
		params.Page,
		params.Limit,
		params.Name,
		params.ProvinceID,
		params.CityID,
		params.Phone,
		params.Status,
		params.StartCreatedAt,
		params.EndCreatedAt,
		params.StartUpdatedAt,
		params.EndUpdatedAt,
	)
	response.JSON(c, gin.H{
		"data":  data,
		"count": count,
	}, err)
}

// 详情
func (LotteryMember) Detail(c *gin.Context) {
	var params struct {
		ID string `json:"id"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	MerchantID := c.GetString("merchant_id")
	info, err := lottery.LotteryMemberService{}.Detail(MerchantID, params.ID)
	response.JSON(c, info, err)
}

// LotteryMemberActivityLog 会员活动记录
type LotteryMemberActivityLog struct{}

// Add 添加日志测试
func (LotteryMemberActivityLog) Add(c *gin.Context) {
	var params struct {
		Type       int    `json:"type"`         // type 日志类型 1 注册会员 2参与抽奖
		SalesID    string `json:"sales_id"`     // 机器识别码
		ActivityID string `json:"activity_id"`  // 活动ID
		MemberID   string `json:"member_id"`    // 用户ID
		OutTradeNo string `json:"out_trade_no"` // 用户ID
		Phone      string `json:"phone"`        // 用户ID
	}
	err := c.ShouldBindBodyWith(&params, binding.JSON)
	if err != nil {
		response.JSON(c, nil, errorx.New("参数错误！", -1))
		return
	}

	err = lottery.LotteryMemberActivityLogService{}.Add(
		params.Type,
		params.SalesID,
		params.ActivityID,
		params.MemberID,
		params.OutTradeNo,
		params.Phone,
		"",
	)

	response.JSON(c, nil, err)
}

// List日志列表
func (LotteryMemberActivityLog) Detail(c *gin.Context) {
	var params struct {
		MemberID string `json:"member_id"`
		Phone    string `json:"phone"`
		Limit    int    `json:"limit"`
		Page     int    `json:"page"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	// 返回会员列表数据
	list, total, err := lottery.LotteryMemberActivityLogService{}.LogList(
		c.Request.Context(),
		params.Page,
		params.Limit,
		params.Phone,
		params.MemberID,
	)
	response.JSON(c, gin.H{
		"list":  list,
		"total": total,
	}, err)
}

// List日志列表
func (LotteryMemberActivityLog) List(c *gin.Context) {
	var params struct {
		Page       int    `json:"page"`
		Limit      int    `json:"limit"`
		Name       string `json:"name"`
		ProvinceID string `json:"province_id"`
		CityID     string `json:"city_id"`
		Phone      string `json:"phone"`
		Status     int    `json:"status"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)

	MerchantID := c.GetString("merchant_id")

	// 返回会员列表数据
	data, count, err := lottery.LotteryMemberActivityLogService{}.List(
		c.Request.Context(),
		MerchantID,
		params.Page,
		params.Limit,
		params.Phone,
	)
	response.JSON(c, gin.H{
		"data":  data,
		"count": count,
	}, err)
}

// 抽奖活动数据
type LotteryActivityData struct{}

// GetTrendOfLottery 获取锦鲤活动趋势图数据
func (LotteryActivityData) GetTrendOfLottery(c *gin.Context) {

	var params struct {
		ActivityID string `json:"activity_id"`
		CityID     string `json:"city_id"`
		StartTime  int64  `json:"start_time"`
		EndTime    int64  `json:"end_time"`
	}
	c.ShouldBindBodyWith(&params, binding.JSON)
	// 1. 验证当前的活动是否存在
	detail, _ := lottery.LotteryService{}.Detail(
		c.GetString("merchant_id"),
		params.ActivityID,
	)
	if detail.ID == "" {
		response.JSON(c, nil, errorx.New("锦鲤活动不存在", -1))
		return
	}
	// 2.获取趋势图
	data, err := lottery.LotteryService{}.TrendOfLottery(
		c.GetString("merchant_id"),
		params.ActivityID,
		params.CityID,
		params.StartTime,
		params.EndTime,
	)
	if err != nil {
		response.JSON(c, nil, errorx.New("获取锦鲤活动数据错误", -1))
		return
	} else {
		response.JSON(c, data, err)
	}

}

// 锦鲤活动数据
func (LotteryActivityData) CountData(c *gin.Context) {

	var params struct {
		ActivityID string `json:"activity_id"`
	}

	c.ShouldBindBodyWith(&params, binding.JSON)

	// 1. 验证当前的活动是否存在
	detail, _ := lottery.LotteryService{}.Detail(
		c.GetString("merchant_id"),
		params.ActivityID,
	)
	if detail.ID == "" {
		response.JSON(c, nil, errorx.New("锦鲤活动不存在", -1))
		return
	}
	// 2. 获取锦鲤活动数据
	data, err := lottery.LotteryService{}.CountData(
		c.GetString("merchant_id"),
		params.ActivityID,
	)

	if err != nil {
		response.JSON(c, nil, errorx.New("获取锦鲤活动数据错误", -1))
		return
	} else {
		response.JSON(c, data, err)
	}

}
